/*********************\
* Author:Dzlua
* QQ:505544956
* Time:2017/03/15
\**********************/
#include "StdAfx.h"

namespace DuiLib {

CPaintManagerUI* SDWindowBase::GetPaintManager()
{
    return m_pm;
}

bool SDWindowBase::IsUpdateNeeded() const
{
    return m_pm->IsUpdateNeeded();
}

void SDWindowBase::NeedUpdate()
{
    m_pm->NeedUpdate();
}

void SDWindowBase::Invalidate()
{
    m_pm->Invalidate();
}

void SDWindowBase::Invalidate(RECT& rcItem)
{
    m_pm->Invalidate(rcItem);
}

LPCTSTR SDWindowBase::GetName() const
{
    return m_pm->GetName();
}

HDC SDWindowBase::GetPaintDC() const
{
    return m_pm->GetPaintDC();
}

HWND SDWindowBase::GetPaintWindow() const
{
    return m_pm->GetPaintWindow();
}

HWND SDWindowBase::GetTooltipWindow() const
{
    return m_pm->GetTooltipWindow();
}

/*int SDWindowBase::GetTooltipWindowWidth() const
{
    return m_pm->GetTooltipWindowWidth();
}

void SDWindowBase::SetTooltipWindowWidth(int iWidth)
{
    m_pm->SetTooltipWindowWidth(iWidth);
}

int SDWindowBase::GetHoverTime() const
{
    return m_pm->GetHoverTime();
}

void SDWindowBase::SetHoverTime(int iTime)
{
    m_pm->SetHoverTime(iTime);
}*/

POINT SDWindowBase::GetMousePos() const
{
    return m_pm->GetMousePos();
}

SIZE SDWindowBase::GetClientSize() const
{
    return m_pm->GetClientSize();
}

SIZE SDWindowBase::GetInitSize()
{
    return m_pm->GetInitSize();
}

void SDWindowBase::SetInitSize(int cx, int cy)
{
    m_pm->SetInitSize(cx, cy);
}

RECT& SDWindowBase::GetSizeBox()
{
    return m_pm->GetSizeBox();
}

void SDWindowBase::SetSizeBox(RECT& rcSizeBox)
{
    m_pm->SetSizeBox(rcSizeBox);
}

RECT& SDWindowBase::GetCaptionRect()
{
    return m_pm->GetCaptionRect();
}

void SDWindowBase::SetCaptionRect(RECT& rcCaption)
{
    m_pm->SetCaptionRect(rcCaption);
}

SIZE SDWindowBase::GetRoundCorner() const
{
    return m_pm->GetRoundCorner();
}

void SDWindowBase::SetRoundCorner(int cx, int cy)
{
    m_pm->SetRoundCorner(cx, cy);
}

SIZE SDWindowBase::GetMinInfo() const
{
    return m_pm->GetMinInfo();
}

void SDWindowBase::SetMinInfo(int cx, int cy)
{
    m_pm->SetMinInfo(cx, cy);
}

SIZE SDWindowBase::GetMaxInfo() const
{
    return m_pm->GetMaxInfo();
}

void SDWindowBase::SetMaxInfo(int cx, int cy)
{
    m_pm->SetMaxInfo(cx, cy);
}

bool SDWindowBase::IsShowUpdateRect() const
{
    return m_pm->IsShowUpdateRect();
}

void SDWindowBase::SetShowUpdateRect(bool show)
{
    m_pm->SetShowUpdateRect(show);
}

BYTE SDWindowBase::GetOpacity() const
{
    return m_pm->GetOpacity();
}

void SDWindowBase::SetOpacity(BYTE nOpacity)
{
    m_pm->SetOpacity(nOpacity);
}

bool SDWindowBase::IsLayered()
{
    return m_pm->IsLayered();
}

void SDWindowBase::SetLayered(bool bLayered)
{
    m_pm->SetLayered(bLayered);
}

RECT& SDWindowBase::GetLayeredInset()
{
    return m_pm->GetLayeredInset();
}

void SDWindowBase::SetLayeredInset(RECT& rcLayeredInset)
{
    m_pm->SetLayeredInset(rcLayeredInset);
}

BYTE SDWindowBase::GetLayeredOpacity()
{
    return m_pm->GetLayeredOpacity();
}

void SDWindowBase::SetLayeredOpacity(BYTE nOpacity)
{
    m_pm->SetLayeredOpacity(nOpacity);
}

//LPCTSTR SDWindowBase::GetLayeredImage(){}
//void SDWindowBase::SetLayeredImage(LPCTSTR pstrImage){}

CShadowUI* SDWindowBase::GetShadow()
{
    return m_pm->GetShadow();
}

bool SDWindowBase::ShowCaret(bool bShow)
{
    return m_pm->ShowCaret(bShow);
}

bool SDWindowBase::SetCaretPos(CRichEditUI* obj, int x, int y)
{
    return m_pm->SetCaretPos(obj, x, y);
}

CRichEditUI* SDWindowBase::GetCurrentCaretObject()
{
    return m_pm->GetCurrentCaretObject();
}

bool SDWindowBase::CreateCaret(HBITMAP hBmp, int nWidth, int nHeight)
{
    return m_pm->CreateCaret(hBmp, nWidth, nHeight);
}

void SDWindowBase::DrawCaret(HDC hDC, const RECT& rcPaint)
{
    m_pm->DrawCaret(hDC, rcPaint);
}

void SDWindowBase::SetUseGdiplusText(bool bUse)
{
    m_pm->SetUseGdiplusText(bUse);
}

bool SDWindowBase::IsUseGdiplusText() const
{
    return m_pm->IsUseGdiplusText();
}

void SDWindowBase::SetGdiplusTextRenderingHint(int trh)
{
    m_pm->SetGdiplusTextRenderingHint(trh);
}

int SDWindowBase::GetGdiplusTextRenderingHint() const
{
    return m_pm->GetGdiplusTextRenderingHint();
}

bool SDWindowBase::IsForceUseSharedRes() const
{
    return m_pm->IsForceUseSharedRes();
}

void SDWindowBase::SetForceUseSharedRes(bool bForce)
{
    m_pm->SetForceUseSharedRes(bForce);
}

void SDWindowBase::DeletePtr(void* ptr)
{
    m_pm->DeletePtr(ptr);
}

DWORD SDWindowBase::GetDefaultDisabledColor() const
{
    return m_pm->GetDefaultDisabledColor();
}

void SDWindowBase::SetDefaultDisabledColor(DWORD dwColor, bool bShared /*= false*/)
{
    m_pm->SetDefaultDisabledColor(dwColor, bShared);
}

DWORD SDWindowBase::GetDefaultFontColor() const
{
    return m_pm->GetDefaultFontColor();
}

void SDWindowBase::SetDefaultFontColor(DWORD dwColor, bool bShared /*= false*/)
{
    m_pm->SetDefaultFontColor(dwColor, bShared);
}

DWORD SDWindowBase::GetDefaultLinkFontColor() const
{
    return m_pm->GetDefaultLinkFontColor();
}

void SDWindowBase::SetDefaultLinkFontColor(DWORD dwColor, bool bShared /*= false*/)
{
    m_pm->SetDefaultLinkFontColor(dwColor, bShared);
}

DWORD SDWindowBase::GetDefaultLinkHoverFontColor() const
{
    return m_pm->GetDefaultLinkHoverFontColor();
}

void SDWindowBase::SetDefaultLinkHoverFontColor(DWORD dwColor, bool bShared /*= false*/)
{
    m_pm->SetDefaultLinkHoverFontColor(dwColor, bShared);
}

DWORD SDWindowBase::GetDefaultSelectedBkColor() const
{
    return m_pm->GetDefaultSelectedBkColor();
}

void SDWindowBase::SetDefaultSelectedBkColor(DWORD dwColor, bool bShared /*= false*/)
{
    m_pm->SetDefaultSelectedBkColor(dwColor, bShared);
}

TFontInfo* SDWindowBase::GetDefaultFontInfo()
{
    return m_pm->GetDefaultFontInfo();
}

void SDWindowBase::SetDefaultFont(LPCTSTR pStrFontName, int nSize, bool bBold, bool bUnderline, bool bItalic, bool bShared /*= false*/)
{
    m_pm->SetDefaultFont(pStrFontName, nSize, bBold, bUnderline, bItalic, bShared);
}

DWORD SDWindowBase::GetCustomFontCount(bool bShared /*= false*/) const
{
    return m_pm->GetCustomFontCount(bShared);
}

void SDWindowBase::AddFontArray(LPCTSTR pstrPath)
{
    m_pm->AddFontArray(pstrPath);
}

HFONT SDWindowBase::AddFont(int id, LPCTSTR pStrFontName, int nSize, bool bBold, bool bUnderline, bool bItalic, bool bShared /*= false*/)
{
    return m_pm->AddFont(id, pStrFontName, nSize, bBold, bUnderline, bItalic, bShared);
}

HFONT SDWindowBase::GetFont(int id)
{
    return m_pm->GetFont(id);
}

HFONT SDWindowBase::GetFont(LPCTSTR pStrFontName, int nSize, bool bBold, bool bUnderline, bool bItalic)
{
    return m_pm->GetFont(pStrFontName, nSize, bBold, bUnderline, bItalic);
}

int SDWindowBase::GetFontIndex(HFONT hFont, bool bShared /*= false*/)
{
    return m_pm->GetFontIndex(hFont, bShared);
}

int SDWindowBase::GetFontIndex(LPCTSTR pStrFontName, int nSize, bool bBold, bool bUnderline, bool bItalic, bool bShared /*= false*/)
{
    return m_pm->GetFontIndex(pStrFontName, nSize, bBold, bUnderline, bItalic, bShared);
}

void SDWindowBase::RemoveFont(HFONT hFont, bool bShared /*= false*/)
{
    m_pm->RemoveFont(hFont, bShared);
}

void SDWindowBase::RemoveFont(int id, bool bShared /*= false*/)
{
    m_pm->RemoveFont(id, bShared);
}

void SDWindowBase::RemoveAllFonts(bool bShared /*= false*/)
{
    m_pm->RemoveAllFonts(bShared);
}

TFontInfo* SDWindowBase::GetFontInfo(int id)
{
    return m_pm->GetFontInfo(id);
}

TFontInfo* SDWindowBase::GetFontInfo(HFONT hFont)
{
    return m_pm->GetFontInfo(hFont);
}

const TImageInfo* SDWindowBase::GetImage(LPCTSTR bitmap)
{
    return m_pm->GetImage(bitmap);
}

const TImageInfo* SDWindowBase::GetImageEx(LPCTSTR bitmap, LPCTSTR type /*= NULL*/, DWORD mask /*= 0*/, bool bUseHSL /*= false*/, HINSTANCE instance /*= NULL*/)
{
    return m_pm->GetImageEx(bitmap, type, mask, bUseHSL, instance);
}
const TImageInfo* SDWindowBase::AddImage(LPCTSTR bitmap, LPCTSTR type /*= NULL*/, DWORD mask /*= 0*/, bool bUseHSL /*= false*/, bool bShared /*= false*/, HINSTANCE instance /*= NULL*/)
{
    return m_pm->AddImage(bitmap, type, mask, bUseHSL, bShared, instance);
}

const TImageInfo* SDWindowBase::AddImage(LPCTSTR bitmap, HBITMAP hBitmap, int iWidth, int iHeight, bool bAlpha, bool bShared /*= false*/)
{
    return m_pm->AddImage(bitmap, hBitmap, iWidth, iHeight, bAlpha, bShared);
}

void SDWindowBase::RemoveImage(LPCTSTR bitmap, bool bShared /*= false*/)
{
    m_pm->RemoveImage(bitmap, bShared);
}

void SDWindowBase::RemoveAllImages(bool bShared /*= false*/)
{
    m_pm->RemoveAllImages(bShared);
}

void SDWindowBase::ReloadImages()
{
    m_pm->ReloadImages();
}

const TDrawInfo* SDWindowBase::GetDrawInfo(LPCTSTR pStrImage, LPCTSTR pStrModify)
{
    return m_pm->GetDrawInfo(pStrImage, pStrModify);
}

void SDWindowBase::RemoveDrawInfo(LPCTSTR pStrImage, LPCTSTR pStrModify)
{
    m_pm->RemoveDrawInfo(pStrImage, pStrModify);
}

void SDWindowBase::RemoveAllDrawInfos()
{
    m_pm->RemoveAllDrawInfos();
}

void SDWindowBase::AddDefaultAttributeList(LPCTSTR pStrControlName, LPCTSTR pStrControlAttrList, bool bShared /*= false*/)
{
    m_pm->AddDefaultAttributeList(pStrControlName, pStrControlAttrList, bShared);
}

LPCTSTR SDWindowBase::GetDefaultAttributeList(LPCTSTR pStrControlName) const
{
    return m_pm->GetDefaultAttributeList(pStrControlName);
}

bool SDWindowBase::RemoveDefaultAttributeList(LPCTSTR pStrControlName, bool bShared /*= false*/)
{
    return m_pm->RemoveDefaultAttributeList(pStrControlName, bShared);
}

void SDWindowBase::RemoveAllDefaultAttributeList(bool bShared /*= false*/)
{
    m_pm->RemoveAllDefaultAttributeList(bShared);
}

void SDWindowBase::AddWindowCustomAttribute(LPCTSTR pstrName, LPCTSTR pstrAttr)
{
    m_pm->AddWindowCustomAttribute(pstrName, pstrAttr);
}

LPCTSTR SDWindowBase::GetWindowCustomAttribute(LPCTSTR pstrName) const
{
    return m_pm->GetWindowCustomAttribute(pstrName);
}

bool SDWindowBase::RemoveWindowCustomAttribute(LPCTSTR pstrName)
{
    return m_pm->RemoveWindowCustomAttribute(pstrName);
}

void SDWindowBase::RemoveAllWindowCustomAttribute()
{
    m_pm->RemoveAllWindowCustomAttribute();
}

void SDWindowBase::AddStyle(LPCTSTR pName, LPCTSTR pStyle, bool bShared /*= false*/)
{
    m_pm->AddStyle(pName, pStyle, bShared);
}

LPCTSTR SDWindowBase::GetStyle(LPCTSTR pName) const
{
    return m_pm->GetStyle(pName);
}

BOOL SDWindowBase::RemoveStyle(LPCTSTR pName, bool bShared /*= false*/)
{
    return m_pm->RemoveStyle(pName, bShared);
}

const CStdStringPtrMap& SDWindowBase::GetStyles(bool bShared /*= false*/) const
{
    return m_pm->GetStyles(bShared);
}

void SDWindowBase::RemoveAllStyle(bool bShared /*= false*/)
{
    m_pm->RemoveAllStyle(bShared);
}

const TImageInfo* SDWindowBase::GetImageString(LPCTSTR pStrImage, LPCTSTR pStrModify /*= NULL*/)
{
    return m_pm->GetImageString(pStrImage, pStrModify);
}

bool SDWindowBase::InitDragDrop()
{
    return m_pm->InitDragDrop();
}

bool SDWindowBase::OnDrop(FORMATETC* pFmtEtc, STGMEDIUM& medium,DWORD *pdwEffect)
{
    return m_pm->OnDrop(pFmtEtc, medium, pdwEffect);
}

bool SDWindowBase::AttachDialog(CControlUI* pControl)
{
    return m_pm->AttachDialog(pControl);
}

bool SDWindowBase::InitControls(CControlUI* pControl, CControlUI* pParent /*= NULL*/)
{
    return m_pm->InitControls(pControl, pParent);
}

void SDWindowBase::ReapObjects(CControlUI* pControl)
{
    m_pm->ReapObjects(pControl);
}

bool SDWindowBase::AddOptionGroup(LPCTSTR pStrGroupName, CControlUI* pControl)
{
    return m_pm->AddOptionGroup(pStrGroupName, pControl);
}

CStdPtrArray* SDWindowBase::GetOptionGroup(LPCTSTR pStrGroupName)
{
    return m_pm->GetOptionGroup(pStrGroupName);
}

void SDWindowBase::RemoveOptionGroup(LPCTSTR pStrGroupName, CControlUI* pControl)
{
    m_pm->RemoveOptionGroup(pStrGroupName, pControl);
}

void SDWindowBase::RemoveAllOptionGroups()
{
    m_pm->RemoveAllOptionGroups();
}

CControlUI* SDWindowBase::GetFocus() const
{
    return m_pm->GetFocus();
}

void SDWindowBase::SetFocus(CControlUI* pControl)
{
    m_pm->SetFocus(pControl);
}

void SDWindowBase::SetFocusNeeded(CControlUI* pControl)
{
    m_pm->SetFocusNeeded(pControl);
}

bool SDWindowBase::SetNextTabControl(bool bForward /*= true*/)
{
    return m_pm->SetNextTabControl(bForward);
}

bool SDWindowBase::SetTimer(CControlUI* pControl, UINT nTimerID, UINT uElapse)
{
    return m_pm->SetTimer(pControl, nTimerID, uElapse);
}

bool SDWindowBase::KillTimer(CControlUI* pControl, UINT nTimerID)
{
    return m_pm->KillTimer(pControl, nTimerID);
}

void SDWindowBase::KillTimer(CControlUI* pControl)
{
    m_pm->KillTimer(pControl);
}

void SDWindowBase::RemoveAllTimers()
{
    m_pm->RemoveAllTimers();
}

void SDWindowBase::SetCapture()
{
    m_pm->SetCapture();
}

void SDWindowBase::ReleaseCapture()
{
    m_pm->ReleaseCapture();
}

bool SDWindowBase::IsCaptured()
{
    return m_pm->IsCaptured();
}

bool SDWindowBase::IsPainting()
{
    return m_pm->IsPainting();
}

void SDWindowBase::SetPainting(bool bIsPainting)
{
    m_pm->SetPainting(bIsPainting);
}

bool SDWindowBase::AddNotifier(INotifyUI* pControl)
{
    return m_pm->AddNotifier(pControl);
}

bool SDWindowBase::RemoveNotifier(INotifyUI* pControl)
{
    return m_pm->RemoveNotifier(pControl);
}

void SDWindowBase::SendNotify(TNotifyUI& Msg, bool bAsync /*= false*/)
{
    m_pm->SendNotify(Msg, bAsync);
}

void SDWindowBase::SendNotify(CControlUI* pControl, LPCTSTR pstrMessage, WPARAM wParam /*= 0*/, LPARAM lParam /*= 0*/, bool bAsync /*= false*/)
{
    m_pm->SendNotify(pControl, pstrMessage, wParam, lParam, bAsync);
}

bool SDWindowBase::AddPreMessageFilter(IMessageFilterUI* pFilter)
{
    return m_pm->AddPreMessageFilter(pFilter);
}

bool SDWindowBase::RemovePreMessageFilter(IMessageFilterUI* pFilter)
{
    return m_pm->RemovePreMessageFilter(pFilter);
}

bool SDWindowBase::AddMessageFilter(IMessageFilterUI* pFilter)
{
    return m_pm->AddMessageFilter(pFilter);
}

bool SDWindowBase::RemoveMessageFilter(IMessageFilterUI* pFilter)
{
    return m_pm->RemoveMessageFilter(pFilter);
}

int SDWindowBase::GetPostPaintCount() const
{
    return m_pm->GetPostPaintCount();
}

bool SDWindowBase::IsPostPaint(CControlUI* pControl)
{
    return m_pm->IsPostPaint(pControl);
}

bool SDWindowBase::AddPostPaint(CControlUI* pControl)
{
    return m_pm->AddPostPaint(pControl);
}

bool SDWindowBase::RemovePostPaint(CControlUI* pControl)
{
    return m_pm->RemovePostPaint(pControl);
}

bool SDWindowBase::SetPostPaintIndex(CControlUI* pControl, int iIndex)
{
    return m_pm->SetPostPaintIndex(pControl, iIndex);
}

int SDWindowBase::GetPaintChildWndCount() const
{
    return m_pm->GetPaintChildWndCount();
}

bool SDWindowBase::AddPaintChildWnd(HWND hChildWnd)
{
    return m_pm->AddPaintChildWnd(hChildWnd);
}

bool SDWindowBase::RemovePaintChildWnd(HWND hChildWnd)
{
    return m_pm->RemovePaintChildWnd(hChildWnd);
}

void SDWindowBase::AddDelayedCleanup(CControlUI* pControl)
{
    m_pm->AddDelayedCleanup(pControl);
}

bool SDWindowBase::AddTranslateAccelerator(ITranslateAccelerator *pTranslateAccelerator)
{
    return m_pm->AddTranslateAccelerator(pTranslateAccelerator);
}

bool SDWindowBase::RemoveTranslateAccelerator(ITranslateAccelerator *pTranslateAccelerator)
{
    return m_pm->RemoveTranslateAccelerator(pTranslateAccelerator);
}

bool SDWindowBase::TranslateAccelerator(LPMSG pMsg)
{
    return m_pm->TranslateAccelerator(pMsg);
}

CControlUI* SDWindowBase::GetRoot() const
{
    return m_pm->GetRoot();
}

CControlUI* SDWindowBase::FindControl(POINT pt) const
{
    return m_pm->FindControl(pt);
}

CControlUI* SDWindowBase::FindControl(LPCTSTR pstrName) const
{
    return m_pm->FindControl(pstrName);
}

CControlUI* SDWindowBase::FindSubControlByPoint(CControlUI* pParent, POINT pt) const
{
    return m_pm->FindSubControlByPoint(pParent, pt);
}

CControlUI* SDWindowBase::FindSubControlByName(CControlUI* pParent, LPCTSTR pstrName) const
{
    return m_pm->FindSubControlByName(pParent, pstrName);
}

CControlUI* SDWindowBase::FindSubControlByClass(CControlUI* pParent, LPCTSTR pstrClass, int iIndex /*= 0*/)
{
    return m_pm->FindSubControlByClass(pParent, pstrClass, iIndex);
}

CStdPtrArray* SDWindowBase::FindSubControlsByClass(CControlUI* pParent, LPCTSTR pstrClass)
{
    return m_pm->FindSubControlsByClass(pParent, pstrClass);
}

CDPI* SDWindowBase::GetDPIObj()
{
    return m_pm->GetDPIObj();
}

void SDWindowBase::ResetDPIAssets()
{
    m_pm->ResetDPIAssets();
}

void SDWindowBase::RebuildFont(TFontInfo* pFontInfo)
{
    m_pm->RebuildFont(pFontInfo);
}

void SDWindowBase::SetDPI(int iDPI)
{
    m_pm->SetDPI(iDPI);
}

bool SDWindowBase::MessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& lRes)
{
    return m_pm->MessageHandler(uMsg, wParam, lParam, lRes);
}

bool SDWindowBase::PreMessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT& lRes)
{
    return m_pm->PreMessageHandler(uMsg, wParam, lParam, lRes);
}

void SDWindowBase::UsedVirtualWnd(bool bUsed)
{
    m_pm->UsedVirtualWnd(bUsed);
}

}
